<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        var x = '全局变量';
        {
            let x = '局部变量';
            console.log(x); // 局部变量
        }
        console.log(x); // 全局变量
        // et表示声明变量，而const表示声明常量，两者都为块级作用域；
        // const 声明的变量都会被认为是常量，意思就是它的值被设置完成后就不能再修改了：
         const a = 1
        // a = 0 //报错
        // 如果const的是一个对象，对象所包含的值是可以被修改的。
        // 抽象一点儿说，就是对象所指向的地址没有变就行：
        const student = { name: 'cc' }
        student.name = 'yy';// 不报错
        // student  = { name: 'yy' };// 报错
//         在ES6之前，我们往往这么处理模板字符串：
// 通过“\”和“+”来构建模板
        $("body").html("This demonstrates the output of HTML \
        content to the page, including student's\
        " + name + ", " + seatNumber + ", " + sex + " and so on.");
        // 而对ES6来说
//         基本的字符串格式化。将表达式嵌入字符串中进行拼接。用${}来界定；
// ES6反引号(``)直接搞定；
          $("body").html(`This demonstrates the output of HTML content to the page,
          including student's ${name}, ${seatNumber}, ${sex} and so on.`);
//         箭头函数最直观的三个特点。
//
//         不需要 function 关键字来创建函数
//         省略 return 关键字
//         继承当前上下文的 this 关键字
        // ES5
        var add = function (a, b) {
            return a + b;
        };
        // 使用箭头函数
        var add = (a, b) => a + b;
        // ES5
        [1,2,3].map((function(x){
            return x + 1;
        }).bind(this));
        // 使用箭头函数
        [1,2,3].map(x => x + 1);

        // ES6之前，当未传入参数时，text = 'default'；
        function printText(text) {
            text = text || 'default';
            console.log(text);
        }

        // ES6；
        function printText(text = 'default') {
            console.log(text);
        }

        printText('hello'); // hello
        printText();// default


        当被用于迭代器中时，它是一个 Spread 操作符：

function foo(x,y,z) {
    console.log(x,y,z);
}

        let arr = [1,2,3];
        foo(...arr); // 1 2 3
        当被用于函数传参时，是一个 Rest 操作符：当被用于函数传参时，是一个 Rest 操作符：

function foo(...args) {
            console.log(args);
        }
        foo( 1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]


        //ES6 支持二进制和八进制的字面量，通过在数字前面添加 0o 或者0O 即可将其转换为八进制值：

let oValue = 0o10;
        console.log(oValue); // 8

        let bValue = 0b10; // 二进制使用 `0b` 或者 `0B`
        console.log(bValue); // 2


        // 对象
        const student = {
            name: 'Sam',
            age: 22,
            sex: '男'
        }
        // 数组
        // const student = ['Sam', 22, '男'];

        // ES5；
        const name = student.name;
        const age = student.age;
        const sex = student.sex;
        console.log(name + ' --- ' + age + ' --- ' + sex);

        // ES6
        const { name, age, sex } = student;
        console.log(name + ' --- ' + age + ' --- ' + sex);


       // for...of 用于遍历一个迭代器，如数组：

let letters = ['a', 'b', 'c'];
        letters.size = 3;
        for (let letter of letters) {
            console.log(letter);
        }
        // 结果: a, b, c
        //for...in 用来遍历对象中的属性：

 let stus = ["Sam", "22", "男"];
        for (let stu in stus) {
            console.log(stus[stu]);
        }
        // 结果: Sam, 22, 男


    </script>
</head>
<body>

</body>
</html>